home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / hplip / base / logger.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-28  |  14.3 KB  |  460 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import thread
  6. import syslog
  7. import traceback
  8. import string
  9. import os
  10. import re
  11. import pprint
  12. identity = string.maketrans('', '')
  13. unprintable = identity.translate(identity, string.printable)
  14.  
  15. def printable(s):
  16.     return s.translate(identity, unprintable)
  17.  
  18. DEFAULT_LOG_LEVEL = 'info'
  19.  
  20. class Logger(object):
  21.     LOG_LEVEL_NONE = 99
  22.     LOG_LEVEL_FATAL = 40
  23.     LOG_LEVEL_ERROR = 30
  24.     LOG_LEVEL_WARN = 20
  25.     LOG_LEVEL_INFO = 10
  26.     LOG_LEVEL_DEBUG3 = 3
  27.     LOG_LEVEL_DBG3 = 3
  28.     LOG_LEVEL_DEBUG2 = 2
  29.     LOG_LEVEL_DBG2 = 2
  30.     LOG_LEVEL_DEBUG = 1
  31.     LOG_LEVEL_DBG = 1
  32.     logging_levels = {
  33.         'none': LOG_LEVEL_NONE,
  34.         'fata': LOG_LEVEL_FATAL,
  35.         'fatal': LOG_LEVEL_FATAL,
  36.         'erro': LOG_LEVEL_ERROR,
  37.         'error': LOG_LEVEL_ERROR,
  38.         'warn': LOG_LEVEL_WARN,
  39.         'info': LOG_LEVEL_INFO,
  40.         'debug': LOG_LEVEL_DEBUG,
  41.         'dbg': LOG_LEVEL_DEBUG,
  42.         'debug2': LOG_LEVEL_DEBUG2,
  43.         'dbg2': LOG_LEVEL_DEBUG2,
  44.         'debug3': LOG_LEVEL_DEBUG3,
  45.         'dbg3': LOG_LEVEL_DEBUG3 }
  46.     LOG_TO_DEV_NULL = 0
  47.     LOG_TO_CONSOLE = 1
  48.     LOG_TO_SCREEN = 1
  49.     LOG_TO_FILE = 2
  50.     LOG_TO_CONSOLE_AND_FILE = 3
  51.     LOG_TO_BOTH = 3
  52.     codes = { }
  53.     codes['reset'] = '\x1b[0m'
  54.     codes['bold'] = '\x1b[01m'
  55.     codes['teal'] = '\x1b[36;06m'
  56.     codes['turquoise'] = '\x1b[36;01m'
  57.     codes['fuscia'] = '\x1b[35;01m'
  58.     codes['purple'] = '\x1b[35;06m'
  59.     codes['blue'] = '\x1b[34;01m'
  60.     codes['darkblue'] = '\x1b[34;06m'
  61.     codes['green'] = '\x1b[32;01m'
  62.     codes['darkgreen'] = '\x1b[32;06m'
  63.     codes['yellow'] = '\x1b[33;01m'
  64.     codes['brown'] = '\x1b[33;06m'
  65.     codes['red'] = '\x1b[31;01m'
  66.     codes['darkred'] = '\x1b[31;06m'
  67.     
  68.     def __init__(self, module = '', level = LOG_LEVEL_INFO, where = LOG_TO_CONSOLE_AND_FILE, log_datetime = False, log_file = None):
  69.         self._where = where
  70.         self._log_file = log_file
  71.         self._log_file_f = None
  72.         self._log_datetime = log_datetime
  73.         self._lock = thread.allocate_lock()
  74.         self.module = module
  75.         self.pid = os.getpid()
  76.         self.fmt = True
  77.         self.set_level(level)
  78.  
  79.     
  80.     def set_level(self, level):
  81.         if isinstance(level, str):
  82.             level = level.lower()
  83.             if level in Logger.logging_levels.keys():
  84.                 self._level = Logger.logging_levels.get(level, Logger.LOG_LEVEL_INFO)
  85.                 return True
  86.             self.error('Invalid logging level: %s' % level)
  87.             return False
  88.         isinstance(level, str)
  89.         if isinstance(level, int):
  90.             if level <= level:
  91.                 pass
  92.             elif level <= Logger.LOG_LEVEL_FATAL:
  93.                 self._level = level
  94.             else:
  95.                 self._level = Logger.LOG_LEVEL_ERROR
  96.                 self.error('Invalid logging level: %d' % level)
  97.                 return False
  98.         level <= Logger.LOG_LEVEL_FATAL
  99.         return False
  100.  
  101.     
  102.     def set_module(self, module):
  103.         self.module = module
  104.         self.pid = os.getpid()
  105.  
  106.     
  107.     def no_formatting(self):
  108.         self.fmt = False
  109.  
  110.     
  111.     def set_logfile(self, log_file):
  112.         self._log_file = log_file
  113.         
  114.         try:
  115.             self._log_file_f = file(self._log_file, 'w')
  116.         except IOError:
  117.             self._log_file = None
  118.             self._log_file_f = None
  119.             self._where = Logger.LOG_TO_SCREEN
  120.  
  121.  
  122.     
  123.     def get_logfile(self):
  124.         return self._log_file
  125.  
  126.     
  127.     def set_where(self, where):
  128.         self._where = where
  129.  
  130.     
  131.     def get_level(self):
  132.         return self._level
  133.  
  134.     
  135.     def is_debug(self):
  136.         return self._level <= Logger.LOG_LEVEL_DEBUG3
  137.  
  138.     level = property(get_level, set_level)
  139.     
  140.     def log(self, message, level, newline = True):
  141.         if self._level <= level:
  142.             if self._where in (Logger.LOG_TO_CONSOLE, Logger.LOG_TO_CONSOLE_AND_FILE):
  143.                 
  144.                 try:
  145.                     self._lock.acquire()
  146.                     if level >= Logger.LOG_LEVEL_WARN:
  147.                         out = sys.stderr
  148.                     else:
  149.                         out = sys.stdout
  150.                     
  151.                     try:
  152.                         out.write(message)
  153.                     except UnicodeEncodeError:
  154.                         out.write(message.encode('utf-8'))
  155.  
  156.                     if newline:
  157.                         out.write('\n')
  158.                 finally:
  159.                     self._lock.release()
  160.  
  161.             
  162.         
  163.  
  164.     
  165.     def log_to_file(self, message):
  166.         if self._log_file_f is not None:
  167.             
  168.             try:
  169.                 self._lock.acquire()
  170.                 self._log_file_f.write(message.replace('\x1b', ''))
  171.                 self._log_file_f.write('\n')
  172.             finally:
  173.                 self._lock.release()
  174.  
  175.         
  176.  
  177.     
  178.     def stderr(self, message):
  179.         
  180.         try:
  181.             self._lock.acquire()
  182.             sys.stderr.write('%s: %s\n' % (self.module, message))
  183.         finally:
  184.             self._lock.release()
  185.  
  186.  
  187.     
  188.     def debug(self, message):
  189.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  190.             txt = '%s[%d]: debug: %s' % (self.module, self.pid, message)
  191.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG)
  192.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  193.                 self.log_to_file(txt)
  194.             
  195.         
  196.  
  197.     dbg = debug
  198.     
  199.     def debug2(self, message):
  200.         if self._level <= Logger.LOG_LEVEL_DEBUG2:
  201.             txt = '%s[%d]: debug2: %s' % (self.module, self.pid, message)
  202.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG2)
  203.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  204.                 self.log_to_file(txt)
  205.             
  206.         
  207.  
  208.     dbg2 = debug2
  209.     
  210.     def debug3(self, message):
  211.         if self._level <= Logger.LOG_LEVEL_DEBUG3:
  212.             txt = '%s[%d]: debug3: %s' % (self.module, self.pid, message)
  213.             self.log(self.color(txt, 'blue'), Logger.LOG_LEVEL_DEBUG3)
  214.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  215.                 self.log_to_file(txt)
  216.             
  217.         
  218.  
  219.     dbg3 = debug3
  220.     
  221.     def debug_block(self, title, block):
  222.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  223.             line = '%s[%d]: debug: %s:' % (self.module, self.pid, title)
  224.             self.log(self.color(line, 'blue'), Logger.LOG_LEVEL_DEBUG)
  225.             self.log(self.color(block, 'blue'), Logger.LOG_LEVEL_DEBUG)
  226.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  227.                 self.log_to_file(line % (self.module, self.pid, title))
  228.                 self.log_to_file(block)
  229.             
  230.         
  231.  
  232.     printable = ' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~  '
  233.     
  234.     def log_data(self, data, width = 16):
  235.         if self._level <= Logger.LOG_LEVEL_DEBUG:
  236.             if data:
  237.                 index = 0
  238.                 line = data[0:width]
  239.                 for d in line:
  240.                     txt = _[1](_[1]['%02x' % ord(d)])([
  241.                         ' ' * (width * 3 - 3 * len(line)),
  242.                         ''.join,
  243.                         [],
  244.                         []([ ('.', i)[i in Logger.printable] for i in line ])])
  245.                     self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, txt), 'blue'), Logger.LOG_LEVEL_DEBUG)
  246.                     index += width
  247.                     line = data[index:index + width]
  248.                     []
  249.             else:
  250.                 self.log(self.color('%s[%d]: debug: %s' % (self.module, self.pid, '0000: (no data)'), 'blue'), Logger.LOG_LEVEL_DEBUG)
  251.         
  252.  
  253.     
  254.     def info(self, message = ''):
  255.         if self._level <= Logger.LOG_LEVEL_INFO:
  256.             self.log(message, Logger.LOG_LEVEL_INFO)
  257.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  258.                 self.log_to_file('%s[%d]: info: :%s' % (self.module, self.pid, message))
  259.             
  260.         
  261.  
  262.     information = info
  263.     
  264.     def warn(self, message):
  265.         if self._level <= Logger.LOG_LEVEL_WARN:
  266.             txt = 'warning: %s' % message.encode('utf-8')
  267.             self.log(self.color(txt, 'fuscia'), Logger.LOG_LEVEL_WARN)
  268.             syslog.syslog(syslog.LOG_WARNING, '%s[%d]: %s' % (self.module, self.pid, txt))
  269.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  270.                 self.log_to_file(txt)
  271.             
  272.         
  273.  
  274.     warning = warn
  275.     
  276.     def note(self, message):
  277.         if self._level <= Logger.LOG_LEVEL_WARN:
  278.             txt = 'note: %s' % message
  279.             self.log(self.color(txt, 'green'), Logger.LOG_LEVEL_WARN)
  280.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  281.                 self.log_to_file(txt)
  282.             
  283.         
  284.  
  285.     notice = note
  286.     
  287.     def error(self, message):
  288.         if self._level <= Logger.LOG_LEVEL_ERROR:
  289.             txt = 'error: %s' % message.encode('utf-8')
  290.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_ERROR)
  291.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  292.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  293.                 self.log_to_file(txt)
  294.             
  295.         
  296.  
  297.     
  298.     def fatal(self, message):
  299.         if self._level <= Logger.LOG_LEVEL_FATAL:
  300.             txt = 'fatal error: :%s' % self.module.encode('utf-8')
  301.             self.log(self.color(txt, 'red'), Logger.LOG_LEVEL_DEBUG)
  302.             syslog.syslog(syslog.LOG_ALERT, '%s[%d]: %s' % (self.module, self.pid, txt))
  303.             if self._log_file is not None and self._where in (Logger.LOG_TO_FILE, Logger.LOG_TO_CONSOLE_AND_FILE):
  304.                 self.log_to_file(txt)
  305.             
  306.         
  307.  
  308.     
  309.     def exception(self):
  310.         (typ, value, tb) = sys.exc_info()
  311.         body = 'Traceback (innermost last):\n'
  312.         lst = traceback.format_tb(tb) + traceback.format_exception_only(typ, value)
  313.         body = body + '%-20s %s' % (''.join(lst[:-1]), lst[-1])
  314.         self.fatal(body)
  315.  
  316.     
  317.     def color(self, text, color):
  318.         if self.fmt:
  319.             return ''.join([
  320.                 Logger.codes.get(color, 'bold'),
  321.                 text,
  322.                 Logger.codes['reset']])
  323.         return text
  324.  
  325.     
  326.     def bold(self, text):
  327.         return self.color(text, 'bold')
  328.  
  329.     
  330.     def red(self, text):
  331.         return self.color(text, 'red')
  332.  
  333.     
  334.     def green(self, text):
  335.         return self.color(text, 'green')
  336.  
  337.     
  338.     def purple(self, text):
  339.         return self.color(text, 'purple')
  340.  
  341.     
  342.     def yellow(self, text):
  343.         return self.color(text, 'yellow')
  344.  
  345.     
  346.     def darkgreen(self, text):
  347.         return self.color(text, 'darkgreen')
  348.  
  349.     
  350.     def blue(self, text):
  351.         return self.color(text, 'blue')
  352.  
  353.     
  354.     def _pprint_line(self, indent_level, line, width = 100, level = LOG_LEVEL_DEBUG):
  355.         if line.strip():
  356.             start = ''
  357.             number_chars = 0
  358.             for l in range(indent_level):
  359.                 start = start + ' '
  360.                 number_chars = number_chars + 1
  361.             
  362.             
  363.             try:
  364.                 elem_start = re.findall('(\\<\\W{0,1}\\w+) ?', line)[0]
  365.                 elem_finished = re.findall('([?|\\]\\]]*\\>)', line)[0]
  366.                 attrs = re.findall('(\\S*?\\=".*?")', line)
  367.                 self.log(start + elem_start, level, False)
  368.                 number_chars = len(start + elem_start)
  369.                 for attr in attrs:
  370.                     if attrs.index(attr) + 1 == len(attrs):
  371.                         number_chars = number_chars + len(elem_finished)
  372.                     
  373.                     if number_chars + len(attr) + 1 > width:
  374.                         self.log('\n', level, False)
  375.                         self.log(' ' * (len(start + elem_start) + 1), level, False)
  376.                         number_chars = len(start + elem_start) + 1
  377.                     else:
  378.                         self.log(' ', level, False)
  379.                         number_chars = number_chars + 1
  380.                     self.log(attr, level, False)
  381.                     number_chars = number_chars + len(attr)
  382.                 
  383.                 self.log(elem_finished + '\n', level, False)
  384.             except IndexError:
  385.                 self.log(start + line + '\n', level, False)
  386.             except:
  387.                 None<EXCEPTION MATCH>IndexError
  388.             
  389.  
  390.         None<EXCEPTION MATCH>IndexError
  391.  
  392.     
  393.     def _pprint_elem_content(self, indent_level, line, level = LOG_LEVEL_DEBUG):
  394.         if line.strip():
  395.             self.log(' ' * indent_level, level, False)
  396.             self.log(line + '\n', level, False)
  397.         
  398.  
  399.     
  400.     def _get_next_elem(self, data):
  401.         start_pos = data.find('<')
  402.         end_pos = data.find('>') + 1
  403.         retval = data[start_pos:end_pos]
  404.         stopper = retval.rfind('/')
  405.         if stopper < retval.rfind('"'):
  406.             stopper = -1
  407.         
  408.         if stopper > -1:
  409.             pass
  410.         single = retval.find('>') - stopper < stopper - retval.find('<')
  411.         ignore_excl = retval.find('<!') > -1
  412.         ignore_question = retval.find('<?') > -1
  413.         if ignore_excl:
  414.             cdata = retval.find('<![CDATA[') > -1
  415.             if cdata:
  416.                 end_pos = data.find(']]>')
  417.                 if end_pos > -1:
  418.                     end_pos = end_pos + len(']]>')
  419.                 
  420.             
  421.         elif ignore_question:
  422.             end_pos = data.find('?>') + len('?>')
  423.         
  424.         if not ignore_excl:
  425.             pass
  426.         ignore = ignore_question
  427.         if not ignore:
  428.             pass
  429.         no_indent = single
  430.         return (start_pos, end_pos, stopper > -1, no_indent)
  431.  
  432.     
  433.     def xml(self, xml, level = LOG_LEVEL_DEBUG, indent = 4, width = 80):
  434.         '''Pretty print xml.
  435.         Use indent to select indentation level. Default is 4   '''
  436.         data = xml
  437.         indent_level = 0
  438.         (start_pos, end_pos, is_stop, no_indent) = self._get_next_elem(data)
  439.         while start_pos > -1 and end_pos > -1:
  440.             self._pprint_elem_content(indent_level, data[:start_pos].strip(), level = level)
  441.             data = data[start_pos:]
  442.             if is_stop and not no_indent:
  443.                 indent_level = indent_level - indent
  444.             
  445.             self._pprint_line(indent_level, data[:end_pos - start_pos], width = width, level = level)
  446.             data = data[end_pos - start_pos:]
  447.             if not is_stop and not no_indent:
  448.                 indent_level = indent_level + indent
  449.             
  450.             if not data:
  451.                 break
  452.                 continue
  453.             (start_pos, end_pos, is_stop, no_indent) = self._get_next_elem(data)
  454.  
  455.     
  456.     def pprint(self, data):
  457.         self.info(pprint.pformat(data))
  458.  
  459.  
  460.